package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;
import br.com.telescope.sql.Filter;

/**
 * API de persistência de dados da entidade PLANO_EXECUCAO
 * @author Gerado pelo Telescope
 */
public class EntPlanoExecucao extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.PLANO_EXECUCAO";
    public final static String TABLE_NAME = "PLANO_EXECUCAO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntPlanoExecucao() {
        super();
        initialize();
    }
    
    public EntPlanoExecucao(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aNome = new DomUpper(this,"NOME", "Nome do plano de execução"); 
        aNome.setRequired(true);
        aNome.setSize(64);
        oNome = new DomUpper();
        aDescricao = new DomTextLong(this,"DESCRICAO", "Descrição do plano de execução"); 
        aDescricao.setSize(512);
        oDescricao = new DomTextLong();
        aSituacao = new DomOption(this,"SITUACAO", "Situação do plano"); 
        aSituacao.setRequired(true);
        aSituacao.setSize(1);
        aSituacao.clearOptions();
        aSituacao.addOption("A", "Aprovado");
        aSituacao.addOption("D", "Descontinuado");
        aSituacao.addOption("E", "Em elaboração");
        aSituacao.setDefaultValue("E");
        oSituacao = new DomOption();
        aDataAprovado = new DomDate(this,"DATA_APROVADO", "Data da aprovação"); 
        oDataAprovado = new DomDate();
        aDataDescontinuado = new DomDate(this,"DATA_DESCONTINUADO", "Data (descontinuado)"); 
        oDataDescontinuado = new DomDate();
        aPermiteClonar = new DomFlag(this,"PERMITE_CLONAR", "Permite clonar (copiado)"); 
        aPermiteClonar.setRequired(true);
        aPermiteClonar.setDefaultValue("S");
        oPermiteClonar = new DomFlag();
        aResponsavelElaboracaoId = new DomId(this,"RESPONSAVEL_ELABORACAO_ID", "Responsável (elaboração)"); 
        aResponsavelElaboracaoId.setRequired(true);
        oResponsavelElaboracaoId = new DomId();
        aResponsavelAprovacaoId = new DomId(this,"RESPONSAVEL_APROVACAO_ID", "Responsável (aprovação)"); 
        oResponsavelAprovacaoId = new DomId();
        aResponsavelDescontinuacaoId = new DomId(this,"RESPONSAVEL_DESCONTINUACAO_ID", "Responsável (descontinuação)"); 
        oResponsavelDescontinuacaoId = new DomId();
        aAplicativoOperacaoId = new DomId(this,"APLICATIVO_OPERACAO_ID", "Aplicativo de operação"); 
        aAplicativoOperacaoId.setRequired(true);
        oAplicativoOperacaoId = new DomId();
        aMotivoDescontinuarPlano = new DomTextLong(this,"MOTIVO_DESCONTINUAR_PLANO", "Motivo (descontinuar plano)"); 
        aMotivoDescontinuarPlano.setSize(512);
        oMotivoDescontinuarPlano = new DomTextLong();
        aNroPontosMetadeFaixa = new DomInteger(this,"NRO_PONTOS_METADE_FAIXA", "Nro pontos dentro da metade da faixa"); 
        aNroPontosMetadeFaixa.setRequired(true);
        aNroPontosMetadeFaixa.setSize(0);
        oNroPontosMetadeFaixa = new DomInteger();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Nome do plano de execução
    private DomUpper aNome;
    private DomUpper oNome;
    
    // Descrição do plano de execução
    private DomTextLong aDescricao;
    private DomTextLong oDescricao;
    
    // Situação do plano
    private DomOption aSituacao;
    private DomOption oSituacao;
    
    // Data da aprovação
    private DomDate aDataAprovado;
    private DomDate oDataAprovado;
    
    // Data (descontinuado)
    private DomDate aDataDescontinuado;
    private DomDate oDataDescontinuado;
    
    // Permite clonar (copiado)
    private DomFlag aPermiteClonar;
    private DomFlag oPermiteClonar;
    
    // Responsável (elaboração)
    private DomId aResponsavelElaboracaoId;
    private DomId oResponsavelElaboracaoId;
    
    // Responsável (aprovação)
    private DomId aResponsavelAprovacaoId;
    private DomId oResponsavelAprovacaoId;
    
    // Responsável (descontinuação)
    private DomId aResponsavelDescontinuacaoId;
    private DomId oResponsavelDescontinuacaoId;
    
    // Aplicativo de operação
    private DomId aAplicativoOperacaoId;
    private DomId oAplicativoOperacaoId;
    
    // Motivo (descontinuar plano)
    private DomTextLong aMotivoDescontinuarPlano;
    private DomTextLong oMotivoDescontinuarPlano;
    
    // Nro pontos dentro da metade da faixa
    private DomInteger aNroPontosMetadeFaixa;
    private DomInteger oNroPontosMetadeFaixa;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntPlanoExecucao id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NOME">
    
    public EntPlanoExecucao nome(String value) {
        setNome(value);
        return this;
    }
    
    public void setNome(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyNome();
        } else {
            aNome.setValue(value.getValue());
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(String value) {
        if (value == null) {
            nullifyNome();
        } else {
            aNome.setValue(value);
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(Object value) {
        aNome.setValue(value);
        if (aNome.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNome() {
        if (!aNome.isNull()) {
            aNome.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getNome() {
        return aNome;
    }
    
    public DomUpper oldNome() {
        return oNome;
    }
    
    public String valueOfNome() {
        return aNome.getValue();
    }
    
    public boolean isNomeModified() {
        return aNome.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRICAO">
    
    public EntPlanoExecucao descricao(String value) {
        setDescricao(value);
        return this;
    }
    
    public void setDescricao(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value.getValue());
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(String value) {
        if (value == null) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value);
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(Object value) {
        aDescricao.setValue(value);
        if (aDescricao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescricao() {
        if (!aDescricao.isNull()) {
            aDescricao.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getDescricao() {
        return aDescricao;
    }
    
    public DomTextLong oldDescricao() {
        return oDescricao;
    }
    
    public String valueOfDescricao() {
        return aDescricao.getValue();
    }
    
    public boolean isDescricaoModified() {
        return aDescricao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SITUACAO">
    
    public EntPlanoExecucao situacao(String value) {
        setSituacao(value);
        return this;
    }
    
    public void setSituacao(DomOption value) {
        if (value == null || value.isNull()) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value.getValue());
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(String value) {
        if (value == null) {
            nullifySituacao();
        } else {
            aSituacao.setValue(value);
            if (aSituacao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSituacao(Object value) {
        aSituacao.setValue(value);
        if (aSituacao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySituacao() {
        if (!aSituacao.isNull()) {
            aSituacao.setNull(true);
            setModified(true);
        }
    }
    
    public DomOption getSituacao() {
        return aSituacao;
    }
    
    public DomOption oldSituacao() {
        return oSituacao;
    }
    
    public String valueOfSituacao() {
        return aSituacao.getValue();
    }
    
    public boolean isSituacaoModified() {
        return aSituacao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_APROVADO">
    
    public EntPlanoExecucao dataAprovado(java.sql.Date value) {
        setDataAprovado(value);
        return this;
    }
    
    public void setDataAprovado(DomDate value) {
        if (value == null || value.isNull()) {
            nullifyDataAprovado();
        } else {
            aDataAprovado.setValue(value.getValue());
            if (aDataAprovado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataAprovado(String value) {
        if (value == null) {
            nullifyDataAprovado();
        } else {
            aDataAprovado.setValue(value);
            if (aDataAprovado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataAprovado(java.sql.Date value) {
        aDataAprovado.setValue(value);
        if (aDataAprovado.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataAprovado(Object value) {
        aDataAprovado.setValue(value);
        if (aDataAprovado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataAprovado() {
        if (!aDataAprovado.isNull()) {
            aDataAprovado.setNull(true);
            setModified(true);
        }
    }
    
    public DomDate getDataAprovado() {
        return aDataAprovado;
    }
    
    public DomDate oldDataAprovado() {
        return oDataAprovado;
    }
    
    public java.sql.Date valueOfDataAprovado() {
        return aDataAprovado.getValue();
    }
    
    public boolean isDataAprovadoModified() {
        return aDataAprovado.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DATA_DESCONTINUADO">
    
    public EntPlanoExecucao dataDescontinuado(java.sql.Date value) {
        setDataDescontinuado(value);
        return this;
    }
    
    public void setDataDescontinuado(DomDate value) {
        if (value == null || value.isNull()) {
            nullifyDataDescontinuado();
        } else {
            aDataDescontinuado.setValue(value.getValue());
            if (aDataDescontinuado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataDescontinuado(String value) {
        if (value == null) {
            nullifyDataDescontinuado();
        } else {
            aDataDescontinuado.setValue(value);
            if (aDataDescontinuado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDataDescontinuado(java.sql.Date value) {
        aDataDescontinuado.setValue(value);
        if (aDataDescontinuado.isModified()) {
            setModified(true);
        }
    }
    
    public void setDataDescontinuado(Object value) {
        aDataDescontinuado.setValue(value);
        if (aDataDescontinuado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDataDescontinuado() {
        if (!aDataDescontinuado.isNull()) {
            aDataDescontinuado.setNull(true);
            setModified(true);
        }
    }
    
    public DomDate getDataDescontinuado() {
        return aDataDescontinuado;
    }
    
    public DomDate oldDataDescontinuado() {
        return oDataDescontinuado;
    }
    
    public java.sql.Date valueOfDataDescontinuado() {
        return aDataDescontinuado.getValue();
    }
    
    public boolean isDataDescontinuadoModified() {
        return aDataDescontinuado.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PERMITE_CLONAR">
    
    public EntPlanoExecucao permiteClonar(String value) {
        setPermiteClonar(value);
        return this;
    }
    
    public void setPermiteClonar(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyPermiteClonar();
        } else {
            aPermiteClonar.setValue(value.getValue());
            if (aPermiteClonar.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPermiteClonar(String value) {
        if (value == null) {
            nullifyPermiteClonar();
        } else {
            aPermiteClonar.setValue(value);
            if (aPermiteClonar.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPermiteClonar(Object value) {
        aPermiteClonar.setValue(value);
        if (aPermiteClonar.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPermiteClonar() {
        if (!aPermiteClonar.isNull()) {
            aPermiteClonar.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getPermiteClonar() {
        return aPermiteClonar;
    }
    
    public DomFlag oldPermiteClonar() {
        return oPermiteClonar;
    }
    
    public String valueOfPermiteClonar() {
        return aPermiteClonar.getValue();
    }
    
    public boolean isPermiteClonarModified() {
        return aPermiteClonar.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo RESPONSAVEL_ELABORACAO_ID">
    
    public EntPlanoExecucao responsavelElaboracaoId(Long value) {
        setResponsavelElaboracaoId(value);
        return this;
    }
    
    public void setResponsavelElaboracaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyResponsavelElaboracaoId();
        } else {
            aResponsavelElaboracaoId.setValue(value.getValue());
            if (aResponsavelElaboracaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setResponsavelElaboracaoId(String value) {
        if (value == null) {
            nullifyResponsavelElaboracaoId();
        } else {
            aResponsavelElaboracaoId.setValue(value);
            if (aResponsavelElaboracaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setResponsavelElaboracaoId(Long value) {
        aResponsavelElaboracaoId.setValue(value);
        if (aResponsavelElaboracaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setResponsavelElaboracaoId(Object value) {
        aResponsavelElaboracaoId.setValue(value);
        if (aResponsavelElaboracaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyResponsavelElaboracaoId() {
        if (!aResponsavelElaboracaoId.isNull()) {
            aResponsavelElaboracaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getResponsavelElaboracaoId() {
        return aResponsavelElaboracaoId;
    }
    
    public DomId oldResponsavelElaboracaoId() {
        return oResponsavelElaboracaoId;
    }
    
    public Long valueOfResponsavelElaboracaoId() {
        return aResponsavelElaboracaoId.getValue();
    }
    
    public boolean isResponsavelElaboracaoIdModified() {
        return aResponsavelElaboracaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo RESPONSAVEL_APROVACAO_ID">
    
    public EntPlanoExecucao responsavelAprovacaoId(Long value) {
        setResponsavelAprovacaoId(value);
        return this;
    }
    
    public void setResponsavelAprovacaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyResponsavelAprovacaoId();
        } else {
            aResponsavelAprovacaoId.setValue(value.getValue());
            if (aResponsavelAprovacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setResponsavelAprovacaoId(String value) {
        if (value == null) {
            nullifyResponsavelAprovacaoId();
        } else {
            aResponsavelAprovacaoId.setValue(value);
            if (aResponsavelAprovacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setResponsavelAprovacaoId(Long value) {
        aResponsavelAprovacaoId.setValue(value);
        if (aResponsavelAprovacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setResponsavelAprovacaoId(Object value) {
        aResponsavelAprovacaoId.setValue(value);
        if (aResponsavelAprovacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyResponsavelAprovacaoId() {
        if (!aResponsavelAprovacaoId.isNull()) {
            aResponsavelAprovacaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getResponsavelAprovacaoId() {
        return aResponsavelAprovacaoId;
    }
    
    public DomId oldResponsavelAprovacaoId() {
        return oResponsavelAprovacaoId;
    }
    
    public Long valueOfResponsavelAprovacaoId() {
        return aResponsavelAprovacaoId.getValue();
    }
    
    public boolean isResponsavelAprovacaoIdModified() {
        return aResponsavelAprovacaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo RESPONSAVEL_DESCONTINUACAO_ID">
    
    public EntPlanoExecucao responsavelDescontinuacaoId(Long value) {
        setResponsavelDescontinuacaoId(value);
        return this;
    }
    
    public void setResponsavelDescontinuacaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyResponsavelDescontinuacaoId();
        } else {
            aResponsavelDescontinuacaoId.setValue(value.getValue());
            if (aResponsavelDescontinuacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setResponsavelDescontinuacaoId(String value) {
        if (value == null) {
            nullifyResponsavelDescontinuacaoId();
        } else {
            aResponsavelDescontinuacaoId.setValue(value);
            if (aResponsavelDescontinuacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setResponsavelDescontinuacaoId(Long value) {
        aResponsavelDescontinuacaoId.setValue(value);
        if (aResponsavelDescontinuacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setResponsavelDescontinuacaoId(Object value) {
        aResponsavelDescontinuacaoId.setValue(value);
        if (aResponsavelDescontinuacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyResponsavelDescontinuacaoId() {
        if (!aResponsavelDescontinuacaoId.isNull()) {
            aResponsavelDescontinuacaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getResponsavelDescontinuacaoId() {
        return aResponsavelDescontinuacaoId;
    }
    
    public DomId oldResponsavelDescontinuacaoId() {
        return oResponsavelDescontinuacaoId;
    }
    
    public Long valueOfResponsavelDescontinuacaoId() {
        return aResponsavelDescontinuacaoId.getValue();
    }
    
    public boolean isResponsavelDescontinuacaoIdModified() {
        return aResponsavelDescontinuacaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo APLICATIVO_OPERACAO_ID">
    
    public EntPlanoExecucao aplicativoOperacaoId(Long value) {
        setAplicativoOperacaoId(value);
        return this;
    }
    
    public void setAplicativoOperacaoId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyAplicativoOperacaoId();
        } else {
            aAplicativoOperacaoId.setValue(value.getValue());
            if (aAplicativoOperacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAplicativoOperacaoId(String value) {
        if (value == null) {
            nullifyAplicativoOperacaoId();
        } else {
            aAplicativoOperacaoId.setValue(value);
            if (aAplicativoOperacaoId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAplicativoOperacaoId(Long value) {
        aAplicativoOperacaoId.setValue(value);
        if (aAplicativoOperacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void setAplicativoOperacaoId(Object value) {
        aAplicativoOperacaoId.setValue(value);
        if (aAplicativoOperacaoId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAplicativoOperacaoId() {
        if (!aAplicativoOperacaoId.isNull()) {
            aAplicativoOperacaoId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getAplicativoOperacaoId() {
        return aAplicativoOperacaoId;
    }
    
    public DomId oldAplicativoOperacaoId() {
        return oAplicativoOperacaoId;
    }
    
    public Long valueOfAplicativoOperacaoId() {
        return aAplicativoOperacaoId.getValue();
    }
    
    public boolean isAplicativoOperacaoIdModified() {
        return aAplicativoOperacaoId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MOTIVO_DESCONTINUAR_PLANO">
    
    public EntPlanoExecucao motivoDescontinuarPlano(String value) {
        setMotivoDescontinuarPlano(value);
        return this;
    }
    
    public void setMotivoDescontinuarPlano(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyMotivoDescontinuarPlano();
        } else {
            aMotivoDescontinuarPlano.setValue(value.getValue());
            if (aMotivoDescontinuarPlano.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMotivoDescontinuarPlano(String value) {
        if (value == null) {
            nullifyMotivoDescontinuarPlano();
        } else {
            aMotivoDescontinuarPlano.setValue(value);
            if (aMotivoDescontinuarPlano.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMotivoDescontinuarPlano(Object value) {
        aMotivoDescontinuarPlano.setValue(value);
        if (aMotivoDescontinuarPlano.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMotivoDescontinuarPlano() {
        if (!aMotivoDescontinuarPlano.isNull()) {
            aMotivoDescontinuarPlano.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getMotivoDescontinuarPlano() {
        return aMotivoDescontinuarPlano;
    }
    
    public DomTextLong oldMotivoDescontinuarPlano() {
        return oMotivoDescontinuarPlano;
    }
    
    public String valueOfMotivoDescontinuarPlano() {
        return aMotivoDescontinuarPlano.getValue();
    }
    
    public boolean isMotivoDescontinuarPlanoModified() {
        return aMotivoDescontinuarPlano.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NRO_PONTOS_METADE_FAIXA">
    
    public EntPlanoExecucao nroPontosMetadeFaixa(Integer value) {
        setNroPontosMetadeFaixa(value);
        return this;
    }
    
    public void setNroPontosMetadeFaixa(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyNroPontosMetadeFaixa();
        } else {
            aNroPontosMetadeFaixa.setValue(value.getValue());
            if (aNroPontosMetadeFaixa.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNroPontosMetadeFaixa(String value) {
        if (value == null) {
            nullifyNroPontosMetadeFaixa();
        } else {
            aNroPontosMetadeFaixa.setValue(value);
            if (aNroPontosMetadeFaixa.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNroPontosMetadeFaixa(Integer value) {
        aNroPontosMetadeFaixa.setValue(value);
        if (aNroPontosMetadeFaixa.isModified()) {
            setModified(true);
        }
    }
    
    public void setNroPontosMetadeFaixa(Object value) {
        aNroPontosMetadeFaixa.setValue(value);
        if (aNroPontosMetadeFaixa.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNroPontosMetadeFaixa() {
        if (!aNroPontosMetadeFaixa.isNull()) {
            aNroPontosMetadeFaixa.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getNroPontosMetadeFaixa() {
        return aNroPontosMetadeFaixa;
    }
    
    public DomInteger oldNroPontosMetadeFaixa() {
        return oNroPontosMetadeFaixa;
    }
    
    public Integer valueOfNroPontosMetadeFaixa() {
        return aNroPontosMetadeFaixa.getValue();
    }
    
    public boolean isNroPontosMetadeFaixaModified() {
        return aNroPontosMetadeFaixa.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.ENSAIO_BANCADA.FK_ENBANC_PLANO_EXECUCAO
        {
            EntEnsaioBancada external = new EntEnsaioBancada(ctx);
            external.findByPlanoExecucao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_PLANO_EXECUCAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Ensaios nas bancadas fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_PLANO_EXECUCAO
        {
            EntInstrucaoTrabalho external = new EntInstrucaoTrabalho(ctx);
            external.findByPlanoExecucao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_PLANO_EXECUCAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Instruções de trabalho fazendo referencia para este registro");
            }
            external.close();
        }
        // Nullify cascade ZTEST.SOLICITACAO_ENSAIO.FK_SOLENS_PLANO_EXECUCAO
        {
            EntSolicitacaoEnsaio external = new EntSolicitacaoEnsaio(ctx);
            external.findByPlanoExecucao(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.SOLICITACAO_ENSAIO.FK_SOLENS_PLANO_EXECUCAO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Solicitações de ensaios fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade ZTEST.CRITERIO_APROVACAO_PLANO_ENSAIO.FK_CAPLEN_PLANO_ENSAIO
        {
            EntCriterioAprovacaoPlanoEnsaio criterioAprovacaoPlanoEnsaio = new EntCriterioAprovacaoPlanoEnsaio(ctx);
            criterioAprovacaoPlanoEnsaio.del("select id from CRITERIO_APROVACAO_PLANO_ENSAIO where PLANO_ENSAIO_ID = " + valueOfId());
        }
        // Delete cascade ZTEST.PONTO_PLANO_EXECUCAO.FK_PUNPEX_PLANO_EXECUCAO
        {
            EntPontoPlanoExecucao pontoPlanoExecucao = new EntPontoPlanoExecucao(ctx);
            pontoPlanoExecucao.del("select id from PONTO_PLANO_EXECUCAO where PLANO_EXECUCAO_ID = " + valueOfId());
        }
        // Delete cascade ZTEST.REGRA_VARIAVEL_PLANO_EXECUCAO.FK_RGVVPE_PLANO_EXECUCAO
        {
            EntRegraVariavelPlanoExecucao regraVariavelPlanoExecucao = new EntRegraVariavelPlanoExecucao(ctx);
            regraVariavelPlanoExecucao.del("select id from REGRA_VARIAVEL_PLANO_EXECUCAO where PLANO_EXECUCAO_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_ENBANC_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.ENSAIO_BANCADA.FK_ENBANC_PLANO_EXECUCAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Ensaios nas bancadas fazendo referencia para este registro! (FK_ENBANC_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_INSTRA_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.INSTRUCAO_TRABALHO.FK_INSTRA_PLANO_EXECUCAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Instruções de trabalho fazendo referencia para este registro! (FK_INSTRA_PLANO_EXECUCAO)");
                return e;
            } else if (msg.indexOf("FK_SOLENS_PLANO_EXECUCAO") >= 0) {
                e = new AdsException("ZTEST.SOLICITACAO_ENSAIO.FK_SOLENS_PLANO_EXECUCAO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Solicitações de ensaios fazendo referencia para este registro! (FK_SOLENS_PLANO_EXECUCAO)");
                return e;
            } else {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("PLANO_EXECUCAO_SEM_CRITERIO_APROVACAO") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.PLANO_EXECUCAO_SEM_CRITERIO_APROVACAO", 
                        Severity.ERROR,
                        "Regra inválida! O plano de execução deve ter 1 ou mais critérios de aprovação cadastrados! (PLANO_EXECUCAO_SEM_CRITERIO_APROVACAO)");
                return e;
            } else if (msg.indexOf("FK_PLAEX_APLICATIVO_OPERACAO") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_APLICATIVO_OPERACAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para APLICATIVO_OPERACAO! (FK_PLAEX_APLICATIVO_OPERACAO)");
                return e;
            } else if (msg.indexOf("UK_PLAEX_NOME") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.UK_PLAEX_NOME", 
                        Severity.ERROR,
                        "Registro duplicado! Nome do plano de execução deve ser único Nome do plano de execução ${NOME} (UK_PLAEX_NOME)");
                return e;
            } else if (msg.indexOf("FK_PLAEX_RESPONSAVEL_DESCONTINUACAO") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_DESCONTINUACAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para RESPONSAVEL_DESCONTINUACAO! (FK_PLAEX_RESPONSAVEL_DESCONTINUACAO)");
                return e;
            } else if (msg.indexOf("FK_PLAEX_RESPONSAVEL_APROVACAO") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_APROVACAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para RESPONSAVEL_APROVACAO! (FK_PLAEX_RESPONSAVEL_APROVACAO)");
                return e;
            } else if (msg.indexOf("FK_PLAEX_RESPONSAVEL_ELABORACAO") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.FK_PLAEX_RESPONSAVEL_ELABORACAO", 
                        Severity.ERROR,
                        "Registro não cadastrado para RESPONSAVEL_ELABORACAO! (FK_PLAEX_RESPONSAVEL_ELABORACAO)");
                return e;
            } else if (msg.indexOf("PK_PLAEX") >= 0) {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.PK_PLAEX", 
                        Severity.ERROR,
                        "ID duplicado! (PK_PLAEX)");
                return e;
            } else {
                e = new AdsException("ZTEST.PLANO_EXECUCAO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aNome);
            allAttributes.add(aDescricao);
            allAttributes.add(aSituacao);
            allAttributes.add(aDataAprovado);
            allAttributes.add(aDataDescontinuado);
            allAttributes.add(aPermiteClonar);
            allAttributes.add(aResponsavelElaboracaoId);
            allAttributes.add(aResponsavelAprovacaoId);
            allAttributes.add(aResponsavelDescontinuacaoId);
            allAttributes.add(aAplicativoOperacaoId);
            allAttributes.add(aMotivoDescontinuarPlano);
            allAttributes.add(aNroPontosMetadeFaixa);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getNome().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByNome(String nome) throws AdsException {
        findBy(new String[] {"NOME"},
                new Object[] {nome});
    }
    
    private EntAplicativoOperacao eAplicativoOperacao;
    
    public EntAplicativoOperacao findAplicativoOperacao() throws AdsException {
        if (getAplicativoOperacaoId().isNull()) {
            return null;
        }
        if (eAplicativoOperacao == null || !valueOfAplicativoOperacaoId().equals(eAplicativoOperacao.valueOfId())) {
            eAplicativoOperacao = new EntAplicativoOperacao(ctx);
            eAplicativoOperacao.find(valueOfAplicativoOperacaoId());
        }
        return eAplicativoOperacao;
    }
    
    /**
     * Ativa o join desta entidade com APLICATIVO_OPERACAO
     * através do atributo APLICATIVO_OPERACAO_ID
     */
    public EntAplicativoOperacao joinAplicativoOperacao() {
        return joinAplicativoOperacao(null);
    }
    public EntAplicativoOperacao joinAplicativoOperacao(String alias) {
        EntAplicativoOperacao entity = new EntAplicativoOperacao(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getAplicativoOperacaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByAplicativoOperacao(long id, String sqlAppend) throws AdsException {
        find("select ID from PLANO_EXECUCAO where APLICATIVO_OPERACAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByAplicativoOperacao(long id) throws AdsException {
        findByAplicativoOperacao(id,"");
    }
    
    public void findByAplicativoOperacao(Entity entidade) throws AdsException {
        findByAplicativoOperacao(entidade.valueOfId(),"");
    }
    
    public void findByAplicativoOperacao(Entity entidade, String sqlAppend) throws AdsException {
        findByAplicativoOperacao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPessoa eResponsavelDescontinuacao;
    
    public EntPessoa findResponsavelDescontinuacao() throws AdsException {
        if (getResponsavelDescontinuacaoId().isNull()) {
            return null;
        }
        if (eResponsavelDescontinuacao == null || !valueOfResponsavelDescontinuacaoId().equals(eResponsavelDescontinuacao.valueOfId())) {
            eResponsavelDescontinuacao = new EntPessoa(ctx);
            eResponsavelDescontinuacao.find(valueOfResponsavelDescontinuacaoId());
        }
        return eResponsavelDescontinuacao;
    }
    
    /**
     * Ativa o join desta entidade com PESSOA
     * através do atributo RESPONSAVEL_DESCONTINUACAO_ID
     */
    public EntPessoa joinResponsavelDescontinuacao() {
        return joinResponsavelDescontinuacao(null);
    }
    public EntPessoa joinResponsavelDescontinuacao(String alias) {
        EntPessoa entity = new EntPessoa(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getResponsavelDescontinuacaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByResponsavelDescontinuacao(long id, String sqlAppend) throws AdsException {
        find("select ID from PLANO_EXECUCAO where RESPONSAVEL_DESCONTINUACAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByResponsavelDescontinuacao(long id) throws AdsException {
        findByResponsavelDescontinuacao(id,"");
    }
    
    public void findByResponsavelDescontinuacao(Entity entidade) throws AdsException {
        findByResponsavelDescontinuacao(entidade.valueOfId(),"");
    }
    
    public void findByResponsavelDescontinuacao(Entity entidade, String sqlAppend) throws AdsException {
        findByResponsavelDescontinuacao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPessoa eResponsavelAprovacao;
    
    public EntPessoa findResponsavelAprovacao() throws AdsException {
        if (getResponsavelAprovacaoId().isNull()) {
            return null;
        }
        if (eResponsavelAprovacao == null || !valueOfResponsavelAprovacaoId().equals(eResponsavelAprovacao.valueOfId())) {
            eResponsavelAprovacao = new EntPessoa(ctx);
            eResponsavelAprovacao.find(valueOfResponsavelAprovacaoId());
        }
        return eResponsavelAprovacao;
    }
    
    /**
     * Ativa o join desta entidade com PESSOA
     * através do atributo RESPONSAVEL_APROVACAO_ID
     */
    public EntPessoa joinResponsavelAprovacao() {
        return joinResponsavelAprovacao(null);
    }
    public EntPessoa joinResponsavelAprovacao(String alias) {
        EntPessoa entity = new EntPessoa(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getResponsavelAprovacaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByResponsavelAprovacao(long id, String sqlAppend) throws AdsException {
        find("select ID from PLANO_EXECUCAO where RESPONSAVEL_APROVACAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByResponsavelAprovacao(long id) throws AdsException {
        findByResponsavelAprovacao(id,"");
    }
    
    public void findByResponsavelAprovacao(Entity entidade) throws AdsException {
        findByResponsavelAprovacao(entidade.valueOfId(),"");
    }
    
    public void findByResponsavelAprovacao(Entity entidade, String sqlAppend) throws AdsException {
        findByResponsavelAprovacao(entidade.valueOfId(),sqlAppend);
    }
    
    private EntPessoa eResponsavelElaboracao;
    
    public EntPessoa findResponsavelElaboracao() throws AdsException {
        if (getResponsavelElaboracaoId().isNull()) {
            return null;
        }
        if (eResponsavelElaboracao == null || !valueOfResponsavelElaboracaoId().equals(eResponsavelElaboracao.valueOfId())) {
            eResponsavelElaboracao = new EntPessoa(ctx);
            eResponsavelElaboracao.find(valueOfResponsavelElaboracaoId());
        }
        return eResponsavelElaboracao;
    }
    
    /**
     * Ativa o join desta entidade com PESSOA
     * através do atributo RESPONSAVEL_ELABORACAO_ID
     */
    public EntPessoa joinResponsavelElaboracao() {
        return joinResponsavelElaboracao(null);
    }
    public EntPessoa joinResponsavelElaboracao(String alias) {
        EntPessoa entity = new EntPessoa(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getResponsavelElaboracaoId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByResponsavelElaboracao(long id, String sqlAppend) throws AdsException {
        find("select ID from PLANO_EXECUCAO where RESPONSAVEL_ELABORACAO_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByResponsavelElaboracao(long id) throws AdsException {
        findByResponsavelElaboracao(id,"");
    }
    
    public void findByResponsavelElaboracao(Entity entidade) throws AdsException {
        findByResponsavelElaboracao(entidade.valueOfId(),"");
    }
    
    public void findByResponsavelElaboracao(Entity entidade, String sqlAppend) throws AdsException {
        findByResponsavelElaboracao(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eAplicativoOperacao = null;
        eResponsavelDescontinuacao = null;
        eResponsavelAprovacao = null;
        eResponsavelElaboracao = null;
    }
    /**
     * Retorna os registros de CRITERIO_APROVACAO_PLANO_ENSAIO que referenciam este registro através do atributo PLANO_ENSAIO_ID
     */
    public EntCriterioAprovacaoPlanoEnsaio findAllCriterioAprovacaoPlanoEnsaioPlanoEnsaio() throws AdsException {
        return findAllCriterioAprovacaoPlanoEnsaioPlanoEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de CRITERIO_APROVACAO_PLANO_ENSAIO que referenciam este registro através do atributo PLANO_ENSAIO_ID
     */
    public EntCriterioAprovacaoPlanoEnsaio findAllCriterioAprovacaoPlanoEnsaioPlanoEnsaio(String sqlAppend) throws AdsException {
        EntCriterioAprovacaoPlanoEnsaio out = new EntCriterioAprovacaoPlanoEnsaio(ctx);
        out.find("select ID from CRITERIO_APROVACAO_PLANO_ENSAIO where PLANO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de REGRA_VARIAVEL_PLANO_EXECUCAO que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntRegraVariavelPlanoExecucao findAllRegraVariavelPlanoExecucaoPlanoExecucao() throws AdsException {
        return findAllRegraVariavelPlanoExecucaoPlanoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de REGRA_VARIAVEL_PLANO_EXECUCAO que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntRegraVariavelPlanoExecucao findAllRegraVariavelPlanoExecucaoPlanoExecucao(String sqlAppend) throws AdsException {
        EntRegraVariavelPlanoExecucao out = new EntRegraVariavelPlanoExecucao(ctx);
        out.find("select ID from REGRA_VARIAVEL_PLANO_EXECUCAO where PLANO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaPlanoExecucao() throws AdsException {
        return findAllEnsaioBancadaPlanoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de ENSAIO_BANCADA que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntEnsaioBancada findAllEnsaioBancadaPlanoExecucao(String sqlAppend) throws AdsException {
        EntEnsaioBancada out = new EntEnsaioBancada(ctx);
        out.find("select ID from ENSAIO_BANCADA where PLANO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de PONTO_PLANO_EXECUCAO que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntPontoPlanoExecucao findAllPontoPlanoExecucaoPlanoExecucao() throws AdsException {
        return findAllPontoPlanoExecucaoPlanoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de PONTO_PLANO_EXECUCAO que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntPontoPlanoExecucao findAllPontoPlanoExecucaoPlanoExecucao(String sqlAppend) throws AdsException {
        EntPontoPlanoExecucao out = new EntPontoPlanoExecucao(ctx);
        out.find("select ID from PONTO_PLANO_EXECUCAO where PLANO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de INSTRUCAO_TRABALHO que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntInstrucaoTrabalho findAllInstrucaoTrabalhoPlanoExecucao() throws AdsException {
        return findAllInstrucaoTrabalhoPlanoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de INSTRUCAO_TRABALHO que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntInstrucaoTrabalho findAllInstrucaoTrabalhoPlanoExecucao(String sqlAppend) throws AdsException {
        EntInstrucaoTrabalho out = new EntInstrucaoTrabalho(ctx);
        out.find("select ID from INSTRUCAO_TRABALHO where PLANO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de SOLICITACAO_ENSAIO que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntSolicitacaoEnsaio findAllSolicitacaoEnsaioPlanoExecucao() throws AdsException {
        return findAllSolicitacaoEnsaioPlanoExecucao("order by ID");
    }
    
    /**
     * Retorna os registros de SOLICITACAO_ENSAIO que referenciam este registro através do atributo PLANO_EXECUCAO_ID
     */
    public EntSolicitacaoEnsaio findAllSolicitacaoEnsaioPlanoExecucao(String sqlAppend) throws AdsException {
        EntSolicitacaoEnsaio out = new EntSolicitacaoEnsaio(ctx);
        out.find("select ID from SOLICITACAO_ENSAIO where PLANO_EXECUCAO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oNroPontosMetadeFaixa.setValue(aNroPontosMetadeFaixa);
        oMotivoDescontinuarPlano.setValue(aMotivoDescontinuarPlano);
        oAplicativoOperacaoId.setValue(aAplicativoOperacaoId);
        oResponsavelDescontinuacaoId.setValue(aResponsavelDescontinuacaoId);
        oResponsavelAprovacaoId.setValue(aResponsavelAprovacaoId);
        oResponsavelElaboracaoId.setValue(aResponsavelElaboracaoId);
        oPermiteClonar.setValue(aPermiteClonar);
        oDataAprovado.setValue(aDataAprovado);
        oDataDescontinuado.setValue(aDataDescontinuado);
        oSituacao.setValue(aSituacao);
        oDescricao.setValue(aDescricao);
        oNome.setValue(aNome);
        oId.setValue(aId);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntPlanoExecucao.class);
            rule.setName("PK_PLAEX");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPlanoExecucao.class);
            rule.setAssociatedEntity(EntAplicativoOperacao.class);
            rule.setName("FK_PLAEX_APLICATIVO_OPERACAO");
            rule.addAttribute(new DomId("APLICATIVO_OPERACAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPlanoExecucao.class);
            rule.setAssociatedEntity(EntPessoa.class);
            rule.setName("FK_PLAEX_RESPONSAVEL_APROVACAO");
            rule.addAttribute(new DomId("RESPONSAVEL_APROVACAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPlanoExecucao.class);
            rule.setAssociatedEntity(EntPessoa.class);
            rule.setName("FK_PLAEX_RESPONSAVEL_DESCONTINUACAO");
            rule.addAttribute(new DomId("RESPONSAVEL_DESCONTINUACAO_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntPlanoExecucao.class);
            rule.setAssociatedEntity(EntPessoa.class);
            rule.setName("FK_PLAEX_RESPONSAVEL_ELABORACAO");
            rule.addAttribute(new DomId("RESPONSAVEL_ELABORACAO_ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntPlanoExecucao.class);
            rule.setName("UK_PLAEX_NOME");
            rule.addAttribute(new DomUpper("NOME",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntPlanoExecucao.class);
            rule.setCheckAttribute(new DomOption("SITUACAO",""));
            rule.setName("CKAV_20651979");
            rule.addAllowableValues(new String[] {"E", "A", "D"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        checkRule(isPlanoExecucaoSemCriterioAprovacaoValid(), "PLANO_EXECUCAO_SEM_CRITERIO_APROVACAO", "O plano de execução deve ter 1 ou mais critérios de aprovação cadastrados!");
    }
    
    @Override
    protected void posInsert() throws AdsException {
        incluirMatrizVariaveisPlano(); //Incluir matriz de variáveis do plano (conforme aplicativo selecionado)
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        calcularSituacaoPlanoEnsaio(); //Calcular situação do plano de ensaio
        checkRule(isPlanoExecucaoSemCriterioAprovacaoValid(), "PLANO_EXECUCAO_SEM_CRITERIO_APROVACAO", "O plano de execução deve ter 1 ou mais critérios de aprovação cadastrados!");
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getPermiteClonar().isNull()) {
            setPermiteClonar(getPermiteClonar().getDefaultValue());
        }
        if (getSituacao().isNull()) {
            setSituacao(getSituacao().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Clonar plano de execução.
     */
    public void clonarPlanoExecucao() throws AdsException {
        // <user-code id="20674601" parentId="20652084" hashcode="146d801f" length="87">
        ctx.pushError("y", Severity.WARNING, "TODO, função clonar plano não implementada....");
        // </user-code>
    }
    
    /**
     * Criar matriz de variáveis para o plano de execução.
     * <p>
     * Incluir as variáveis para o plano de execução:
     * <P>
     * 
     * <P>
     * * selecionar as variáveis associadas ao aplicativo deste plano de 
     * execução
     * <P>
     * * se a variável do aplicativo tem um valor default definido, registrar 
     * com valor válido para o ensaio
     * <P>
     * * senão, atribuir "?" para o valor da variável do ensaio, 
     * caracterizando um valor inválidos
     * <P>
     * * marcar a situação do plano de como "
     * <P>
     */
    public void criarMatrizVariaveisExecucao() throws AdsException {
        // <user-code id="20702285" parentId="20702275" hashcode="7bb9f601" length="3822">
        // import br.com.telescope.sql.Filter;
        
        EntPontoPlanoExecucao pontoPlano = null;
        
        EntAplicativoOperacao app = null;
        EntVariavelAplicativo variavelApp = null;
        EntProcessoAplicativo processoApp = null;
        EntRegraVariavelPlanoExecucao regrasVariaveis = null;
        EntRegraVariavelPlanoExecucao regrasExcluir = null;
        try {
            regrasExcluir = new EntRegraVariavelPlanoExecucao(ctx);
            /*
            regrasExcluir.filterBy()
                    .equal(regrasExcluir.getPlanoExecucaoId(), valueOfId().longValue())
                    .gt(regrasExcluir.getNumeroIteracao(), valueOfvariavelApp.valueOfId())
                    .equal(regrasVariaveis.getProcessoAplicativoId(), variavelApp.valueOfProcessoAplicativoId());
            */
            pontoPlano = findAllPontoPlanoExecucaoPlanoExecucao();
            while (pontoPlano.next()) {
                variavelApp = new EntVariavelAplicativo(ctx);
                processoApp = variavelApp.joinProcessoAplicativo();
                app = variavelApp.joinAplicativoOperacao();
        
                variavelApp.filterBy()
                        .equal(variavelApp.getAplicativoOperacaoId(), valueOfAplicativoOperacaoId().longValue());
        
                regrasVariaveis = new EntRegraVariavelPlanoExecucao(ctx);
                while (variavelApp.next()) {
                    // Verificar se já existe
                    /*
                    int qtdeRegistros = ctx.computeSqlInteger(
                            "select ", 
                            0, 
                            valueOfId(),
                            variavelApp.valueOfId(),
                            variavelApp.valueOfProcessoAplicativoId());
                    if (qtdeRegistros == 0) {
                    */
                    
                    Filter filtro = new Filter();
                    filtro.equal(regrasVariaveis.getPlanoExecucaoId(), valueOfId().longValue())
                            .equal(regrasVariaveis.getVariavelAplicativoId(), variavelApp.valueOfId());
                    
                    if (variavelApp.getProcessoAplicativoId().isNotNull()) {
                        filtro.equal(regrasVariaveis.getProcessoAplicativoId(), variavelApp.valueOfProcessoAplicativoId());
                    }
                    filtro.ge(regrasVariaveis.getNumeroIteracao(), 1);
                    
                    regrasVariaveis.filterBy(filtro);
                    if (!regrasVariaveis.next()) {
                        for (int i = 1; i <= pontoPlano.valueOfQuantidadeIteracoesPonto(); i++) {
                            regrasVariaveis.nullify();
                            regrasVariaveis.nullifyId();
                            regrasVariaveis.setPlanoExecucaoId(valueOfId().longValue());
                            regrasVariaveis.setVariavelAplicativoId(variavelApp.valueOfId().longValue());
                            regrasVariaveis.setPontoPlanoExecucaoId(pontoPlano.valueOfId());
                            if (variavelApp.getProcessoAplicativoId().isNotNull()) {
                                regrasVariaveis.setProcessoAplicativoId(variavelApp.valueOfProcessoAplicativoId());
                            }
                            if (variavelApp.getValorDefault().isNotNull()) {
                                regrasVariaveis.setValorDefault(variavelApp.valueOfValorDefault());
                            }
                            regrasVariaveis.setNumeroIteracao(i);
        
                            regrasVariaveis.ins();
                        }
                    }
                    //}
                }
            }
        } catch (Exception e) {
            ctx.pushError(ENTITY_NAME,
                    Severity.ERROR,
                    "Erro não esperado ao criar a matriz de variáveis para o plano, com base nas variáveis do aplicativo informado!"
                    + "\n" 
                    + "Erro: " + e.toString());
        } finally {
            if (regrasExcluir != null) regrasExcluir.close();
            if (regrasVariaveis != null) regrasVariaveis.close();
            if (processoApp != null) processoApp.close();
            if (variavelApp != null) variavelApp.close();
            if (app != null) app.close();
            if (pontoPlano != null) pontoPlano.close();
        }
        // </user-code>
    }
    
    /**
     * Regra de validação: O plano de execução deve ter 1 ou mais critérios de aprovação cadastrados!
     */
    private Object isPlanoExecucaoSemCriterioAprovacaoValid() throws AdsException {
        // <user-code id="21845743" parentId="21845706" hashcode="-7539bcb3" length="506">
        if (isDataAprovadoModified() && getDataAprovado().isNotNull()) {
            EntCriterioAprovacaoPlanoEnsaio criterio = new EntCriterioAprovacaoPlanoEnsaio(ctx);
            
            criterio.findByPlanoEnsaio(valueOfId().longValue());
            if (!criterio.next()) {
                ctx.pushError(ENTITY_NAME,
                        Severity.ERROR,
                        "Plano de ensaio não pode ser aprovado porque não foram cadastrados os critérios de aprovação para este plano!");
            }
            criterio.close();
        }
        return !ctx.hasErrors();
        // </user-code>
    }
    
    /**
     * Regra de ação: Calcular situação do plano de ensaio
     */
    private void calcularSituacaoPlanoEnsaio() throws AdsException {
        // <user-code id="20674412" parentId="20652035" hashcode="-69c9b634" length="677">
        if (isDataAprovadoModified()) {
            if (getDataAprovado().isNotNull()) {
                setSituacao("A");
                nullifyDataDescontinuado();
                nullifyMotivoDescontinuarPlano();
            } else {
                setSituacao("E");
                nullifyDataDescontinuado();
                nullifyMotivoDescontinuarPlano();
            }
        } else if (isDataDescontinuadoModified()) {
            if (getDataDescontinuado().isNotNull()) {
                setSituacao("D");
            } else if (getDataAprovado().isNotNull()) {
                setSituacao("A");
                nullifyMotivoDescontinuarPlano();
            } else {
                setSituacao("E");
                nullifyDataDescontinuado();
                nullifyMotivoDescontinuarPlano();
            }
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Incluir matriz de variáveis do plano (conforme aplicativo selecionado)
     */
    private void incluirMatrizVariaveisPlano() throws AdsException {
        // <user-code id="20816583" parentId="20816517" hashcode="-8f3ecfd" length="33">
        criarMatrizVariaveisExecucao();
        
        // </user-code>
    }
}
